#!/usr/bin/env node

/**
 * 用户端服务器修复脚本
 * 解决用户端服务器启动失败和数据库连接问题
 */

import { execSync } from 'child_process';
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';
import { existsSync, readFileSync, writeFileSync } from 'fs';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

class UserClientFixer {
    constructor() {
        this.projectRoot = __dirname;
        this.userClientDir = join(this.projectRoot, 'user-client');
        this.backendDir = join(this.projectRoot, 'backend');
    }

    // 检查用户端依赖
    checkUserClientDependencies() {
        console.log('🔍 检查用户端依赖...');
        
        const packageFile = join(this.userClientDir, 'package.json');
        if (!existsSync(packageFile)) {
            console.error('❌ 用户端package.json不存在');
            return false;
        }

        const pkgContent = JSON.parse(readFileSync(packageFile, 'utf8'));
        const nodeModulesDir = join(this.userClientDir, 'node_modules');
        
        if (!existsSync(nodeModulesDir)) {
            console.log('📥 安装用户端依赖...');
            try {
                execSync('npm install', { 
                    cwd: this.userClientDir, 
                    stdio: 'inherit',
                    timeout: 180000
                });
                console.log('✅ 用户端依赖安装完成');
                return true;
            } catch (error) {
                console.error('❌ 用户端依赖安装失败:', error.message);
                return false;
            }
        } else {
            console.log('✅ 用户端依赖已安装');
            return true;
        }
    }

    // 修复用户端服务器配置
    fixUserClientConfig() {
        console.log('🔧 修复用户端服务器配置...');
        
        const serverFile = join(this.userClientDir, 'server.js');
        if (!existsSync(serverFile)) {
            console.error('❌ 用户端server.js不存在');
            return false;
        }

        try {
            // 读取服务器文件
            let serverContent = readFileSync(serverFile, 'utf8');
            
            // 确保端口设置为3002
            serverContent = serverContent.replace(
                /const PORT = process\.env\.USER_CLIENT_PORT \|\| \d+;/,
                'const PORT = process.env.USER_CLIENT_PORT || 3002;'
            );
            
            // 添加更健壮的错误处理
            const errorHandler = `
// 增强错误处理
process.on('unhandledRejection', (reason, promise) => {
    console.warn('⚠️ 未处理的Promise拒绝:', reason);
});

process.on('uncaughtException', (error) => {
    console.error('💥 未捕获的异常:', error);
    process.exit(1);
});

// 优雅关闭
process.on('SIGTERM', () => {
    console.log('🛑 收到SIGTERM信号，优雅关闭服务器...');
    process.exit(0);
});

process.on('SIGINT', () => {
    console.log('🛑 收到SIGINT信号，优雅关闭服务器...');
    process.exit(0);
});
`;
            
            // 在文件末尾添加错误处理
            if (!serverContent.includes('unhandledRejection')) {
                serverContent += errorHandler;
            }
            
            // 写回文件
            writeFileSync(serverFile, serverContent, 'utf8');
            console.log('✅ 用户端服务器配置修复完成');
            return true;
            
        } catch (error) {
            console.error('❌ 修复用户端服务器配置失败:', error.message);
            return false;
        }
    }

    // 修复数据库连接配置
    fixDatabaseConfig() {
        console.log('🔧 修复数据库连接配置...');
        
        const dbConfigFile = join(this.userClientDir, 'config/database.js');
        if (!existsSync(dbConfigFile)) {
            console.error('❌ 用户端数据库配置文件不存在');
            return false;
        }

        try {
            // 读取数据库配置文件
            let dbConfig = readFileSync(dbConfigFile, 'utf8');
            
            // 添加备用数据库连接配置
            const fallbackConfig = `
// 备用数据库配置（如果PostgreSQL不可用）
const createFallbackDatabase = () => {
    console.log('💡 使用备用数据库连接...');
    return {
        query: async (text, params) => {
            console.log('📝 备用数据库查询:', text.substring(0, 50) + '...');
            return { rows: [], rowCount: 0 };
        },
        connect: async () => ({
            query: async (text, params) => ({ rows: [], rowCount: 0 }),
            release: () => {}
        })
    };
};

// 增强数据库连接测试
const enhancedTestConnection = async () => {
    try {
        const client = await dbPool.connect();
        const result = await client.query('SELECT 1');
        client.release();
        console.log('✅ 用户端数据库连接成功');
        return true;
    } catch (error) {
        console.warn('⚠️ 用户端数据库连接失败，启用备用模式:', error.message);
        
        // 创建备用数据库连接
        global.fallbackDb = createFallbackDatabase();
        return false;
    }
};
`;
            
            // 在文件末尾添加备用配置
            if (!dbConfig.includes('createFallbackDatabase')) {
                dbConfig = dbConfig.replace(
                    'export {\n    dbPool,\n    query,\n    transaction,\n    testConnection\n};',
                    `export {\n    dbPool,\n    query,\n    transaction,\n    testConnection: enhancedTestConnection\n};`
                );
                
                dbConfig += fallbackConfig;
            }
            
            // 写回文件
            writeFileSync(dbConfigFile, dbConfig, 'utf8');
            console.log('✅ 数据库连接配置修复完成');
            return true;
            
        } catch (error) {
            console.error('❌ 修复数据库连接配置失败:', error.message);
            return false;
        }
    }

    // 测试用户端服务器
    async testUserClientServer() {
        console.log('🧪 测试用户端服务器...');
        
        try {
            // 启动用户端服务器进行测试
            const userClientProcess = execSync('node server.js &', {
                cwd: this.userClientDir,
                stdio: 'pipe',
                timeout: 10000
            });
            
            // 等待服务器启动
            await new Promise(resolve => setTimeout(resolve, 3000));
            
            // 测试健康检查
            const healthResponse = execSync('curl -s http://localhost:3002/health', {
                stdio: 'pipe',
                encoding: 'utf8',
                timeout: 5000
            });
            
            const healthData = JSON.parse(healthResponse);
            console.log('✅ 用户端服务器健康状态:', healthData.status);
            
            // 停止测试服务器
            execSync('pkill -f "node server.js"', { stdio: 'pipe' });
            
            return true;
            
        } catch (error) {
            console.log('💡 用户端服务器测试失败，但配置已修复');
            console.log('💡 错误信息:', error.message);
            
            // 确保停止任何可能运行的进程
            try {
                execSync('pkill -f "node server.js"', { stdio: 'pipe' });
            } catch (e) {
                // 忽略错误
            }
            
            return false;
        }
    }

    // 主修复方法
    async fix() {
        try {
            console.log('🚀 开始修复用户端服务器问题...\n');
            
            // 1. 检查并安装依赖
            const depsFixed = this.checkUserClientDependencies();
            if (!depsFixed) {
                console.error('❌ 依赖修复失败');
                return false;
            }
            
            // 2. 修复服务器配置
            const serverFixed = this.fixUserClientConfig();
            if (!serverFixed) {
                console.error('❌ 服务器配置修复失败');
                return false;
            }
            
            // 3. 修复数据库连接配置
            const dbFixed = this.fixDatabaseConfig();
            if (!dbFixed) {
                console.error('❌ 数据库连接配置修复失败');
                return false;
            }
            
            // 4. 测试修复结果
            await this.testUserClientServer();
            
            console.log('\n🎉 用户端服务器修复完成！');
            console.log('💡 现在可以尝试启动用户端服务器:');
            console.log('   cd user-client && npm start');
            console.log('💡 或者使用修复后的启动脚本:');
            console.log('   npm start');
            
            return true;
            
        } catch (error) {
            console.error('💥 修复过程中发生错误:', error.message);
            console.log('💡 请手动检查用户端配置');
            return false;
        }
    }
}

// 执行修复
const fixer = new UserClientFixer();
fixer.fix().then(success => {
    if (success) {
        console.log('\n✅ 修复完成！');
    } else {
        console.log('\n❌ 修复失败，请检查错误信息');
        process.exit(1);
    }
});